package com.tjbank.cssys.mybatis.sqlbuilder;

import com.tansun.web.framework.dao.SQLBulider;
import java.io.Serializable;
import java.util.Date;

/**
 * IamGroupSqlBuilder
 * 
 * @author PG(Auto Generator)
 * @version V2.0
 */
public class IamGroupSqlBuilder extends SQLBulider<IamGroupSqlBuilder> implements Serializable {
    private static final long serialVersionUID = -161123581321345589L;

    public IamGroupSqlBuilder() {
        _id = this.toString().split("@")[1];
    }

    public IamGroupSqlBuilder andIdEqualTo(String value) {
        return addAndCriterion("ID", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andIdNotEqualTo(String value) {
        return addAndCriterion("ID", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andIdGreaterThan(String value) {
        return addAndCriterion("ID", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andIdGreaterThanOrEqualTo(String value) {
        return addAndCriterion("ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andIdLessThan(String value) {
        return addAndCriterion("ID", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andIdLessThanOrEqualTo(String value) {
        return addAndCriterion("ID", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andIdIsNull() {
        return addAndCriterion("ID", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andIdIsNotNull() {
        return addAndCriterion("ID", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andIdLikeBoth(String value) {
        return addAndCriterion("ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andIdLikeLeft(String value) {
        return addAndCriterion("ID", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andIdLikeRigth(String value) {
        return addAndCriterion("ID", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andIdNotLikeBoth(String value) {
        return addAndCriterion("ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andIdNotLikeLeft(String value) {
        return addAndCriterion("ID", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andIdNotLikeRigth(String value) {
        return addAndCriterion("ID", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orIdEqualTo(String value) {
        return addOrCriterion("ID", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orIdNotEqualTo(String value) {
        return addOrCriterion("ID", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orIdGreaterThan(String value) {
        return addOrCriterion("ID", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orIdGreaterThanOrEqualTo(String value) {
        return addOrCriterion("ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orIdLessThan(String value) {
        return addOrCriterion("ID", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orIdLessThanOrEqualTo(String value) {
        return addOrCriterion("ID", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orIdIsNull() {
        return addOrCriterion("ID", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orIdIsNotNull() {
        return addOrCriterion("ID", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orIdLikeBoth(String value) {
        return addOrCriterion("ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orIdLikeLeft(String value) {
        return addOrCriterion("ID", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orIdLikeRigth(String value) {
        return addOrCriterion("ID", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orIdNotLikeBoth(String value) {
        return addOrCriterion("ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orIdNotLikeLeft(String value) {
        return addOrCriterion("ID", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orIdNotLikeRigth(String value) {
        return addOrCriterion("ID", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderById(boolean isDesc) {
        return addOrderBy("ID", isDesc);
    }

    public IamGroupSqlBuilder andCodeEqualTo(String value) {
        return addAndCriterion("CODE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andCodeNotEqualTo(String value) {
        return addAndCriterion("CODE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andCodeGreaterThan(String value) {
        return addAndCriterion("CODE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andCodeGreaterThanOrEqualTo(String value) {
        return addAndCriterion("CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andCodeLessThan(String value) {
        return addAndCriterion("CODE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andCodeLessThanOrEqualTo(String value) {
        return addAndCriterion("CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andCodeIsNull() {
        return addAndCriterion("CODE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andCodeIsNotNull() {
        return addAndCriterion("CODE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andCodeLikeBoth(String value) {
        return addAndCriterion("CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andCodeLikeLeft(String value) {
        return addAndCriterion("CODE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andCodeLikeRigth(String value) {
        return addAndCriterion("CODE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andCodeNotLikeBoth(String value) {
        return addAndCriterion("CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andCodeNotLikeLeft(String value) {
        return addAndCriterion("CODE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andCodeNotLikeRigth(String value) {
        return addAndCriterion("CODE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orCodeEqualTo(String value) {
        return addOrCriterion("CODE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orCodeNotEqualTo(String value) {
        return addOrCriterion("CODE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orCodeGreaterThan(String value) {
        return addOrCriterion("CODE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orCodeGreaterThanOrEqualTo(String value) {
        return addOrCriterion("CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orCodeLessThan(String value) {
        return addOrCriterion("CODE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orCodeLessThanOrEqualTo(String value) {
        return addOrCriterion("CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orCodeIsNull() {
        return addOrCriterion("CODE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orCodeIsNotNull() {
        return addOrCriterion("CODE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orCodeLikeBoth(String value) {
        return addOrCriterion("CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orCodeLikeLeft(String value) {
        return addOrCriterion("CODE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orCodeLikeRigth(String value) {
        return addOrCriterion("CODE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orCodeNotLikeBoth(String value) {
        return addOrCriterion("CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orCodeNotLikeLeft(String value) {
        return addOrCriterion("CODE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orCodeNotLikeRigth(String value) {
        return addOrCriterion("CODE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByCode(boolean isDesc) {
        return addOrderBy("CODE", isDesc);
    }

    public IamGroupSqlBuilder andNameEqualTo(String value) {
        return addAndCriterion("NAME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andNameNotEqualTo(String value) {
        return addAndCriterion("NAME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andNameGreaterThan(String value) {
        return addAndCriterion("NAME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andNameGreaterThanOrEqualTo(String value) {
        return addAndCriterion("NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andNameLessThan(String value) {
        return addAndCriterion("NAME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andNameLessThanOrEqualTo(String value) {
        return addAndCriterion("NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andNameIsNull() {
        return addAndCriterion("NAME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andNameIsNotNull() {
        return addAndCriterion("NAME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andNameLikeBoth(String value) {
        return addAndCriterion("NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andNameLikeLeft(String value) {
        return addAndCriterion("NAME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andNameLikeRigth(String value) {
        return addAndCriterion("NAME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andNameNotLikeBoth(String value) {
        return addAndCriterion("NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andNameNotLikeLeft(String value) {
        return addAndCriterion("NAME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andNameNotLikeRigth(String value) {
        return addAndCriterion("NAME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orNameEqualTo(String value) {
        return addOrCriterion("NAME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orNameNotEqualTo(String value) {
        return addOrCriterion("NAME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orNameGreaterThan(String value) {
        return addOrCriterion("NAME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orNameGreaterThanOrEqualTo(String value) {
        return addOrCriterion("NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orNameLessThan(String value) {
        return addOrCriterion("NAME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orNameLessThanOrEqualTo(String value) {
        return addOrCriterion("NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orNameIsNull() {
        return addOrCriterion("NAME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orNameIsNotNull() {
        return addOrCriterion("NAME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orNameLikeBoth(String value) {
        return addOrCriterion("NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orNameLikeLeft(String value) {
        return addOrCriterion("NAME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orNameLikeRigth(String value) {
        return addOrCriterion("NAME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orNameNotLikeBoth(String value) {
        return addOrCriterion("NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orNameNotLikeLeft(String value) {
        return addOrCriterion("NAME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orNameNotLikeRigth(String value) {
        return addOrCriterion("NAME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByName(boolean isDesc) {
        return addOrderBy("NAME", isDesc);
    }

    public IamGroupSqlBuilder andTypeEqualTo(String value) {
        return addAndCriterion("TYPE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andTypeNotEqualTo(String value) {
        return addAndCriterion("TYPE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andTypeGreaterThan(String value) {
        return addAndCriterion("TYPE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andTypeGreaterThanOrEqualTo(String value) {
        return addAndCriterion("TYPE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andTypeLessThan(String value) {
        return addAndCriterion("TYPE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andTypeLessThanOrEqualTo(String value) {
        return addAndCriterion("TYPE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andTypeIsNull() {
        return addAndCriterion("TYPE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andTypeIsNotNull() {
        return addAndCriterion("TYPE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andTypeLikeBoth(String value) {
        return addAndCriterion("TYPE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andTypeLikeLeft(String value) {
        return addAndCriterion("TYPE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andTypeLikeRigth(String value) {
        return addAndCriterion("TYPE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andTypeNotLikeBoth(String value) {
        return addAndCriterion("TYPE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andTypeNotLikeLeft(String value) {
        return addAndCriterion("TYPE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andTypeNotLikeRigth(String value) {
        return addAndCriterion("TYPE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orTypeEqualTo(String value) {
        return addOrCriterion("TYPE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orTypeNotEqualTo(String value) {
        return addOrCriterion("TYPE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orTypeGreaterThan(String value) {
        return addOrCriterion("TYPE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orTypeGreaterThanOrEqualTo(String value) {
        return addOrCriterion("TYPE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orTypeLessThan(String value) {
        return addOrCriterion("TYPE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orTypeLessThanOrEqualTo(String value) {
        return addOrCriterion("TYPE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orTypeIsNull() {
        return addOrCriterion("TYPE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orTypeIsNotNull() {
        return addOrCriterion("TYPE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orTypeLikeBoth(String value) {
        return addOrCriterion("TYPE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orTypeLikeLeft(String value) {
        return addOrCriterion("TYPE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orTypeLikeRigth(String value) {
        return addOrCriterion("TYPE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orTypeNotLikeBoth(String value) {
        return addOrCriterion("TYPE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orTypeNotLikeLeft(String value) {
        return addOrCriterion("TYPE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orTypeNotLikeRigth(String value) {
        return addOrCriterion("TYPE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByType(boolean isDesc) {
        return addOrderBy("TYPE", isDesc);
    }

    public IamGroupSqlBuilder andParentIdEqualTo(String value) {
        return addAndCriterion("PARENT_ID", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andParentIdNotEqualTo(String value) {
        return addAndCriterion("PARENT_ID", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andParentIdGreaterThan(String value) {
        return addAndCriterion("PARENT_ID", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andParentIdGreaterThanOrEqualTo(String value) {
        return addAndCriterion("PARENT_ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andParentIdLessThan(String value) {
        return addAndCriterion("PARENT_ID", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andParentIdLessThanOrEqualTo(String value) {
        return addAndCriterion("PARENT_ID", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andParentIdIsNull() {
        return addAndCriterion("PARENT_ID", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andParentIdIsNotNull() {
        return addAndCriterion("PARENT_ID", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andParentIdLikeBoth(String value) {
        return addAndCriterion("PARENT_ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andParentIdLikeLeft(String value) {
        return addAndCriterion("PARENT_ID", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andParentIdLikeRigth(String value) {
        return addAndCriterion("PARENT_ID", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andParentIdNotLikeBoth(String value) {
        return addAndCriterion("PARENT_ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andParentIdNotLikeLeft(String value) {
        return addAndCriterion("PARENT_ID", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andParentIdNotLikeRigth(String value) {
        return addAndCriterion("PARENT_ID", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orParentIdEqualTo(String value) {
        return addOrCriterion("PARENT_ID", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orParentIdNotEqualTo(String value) {
        return addOrCriterion("PARENT_ID", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orParentIdGreaterThan(String value) {
        return addOrCriterion("PARENT_ID", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orParentIdGreaterThanOrEqualTo(String value) {
        return addOrCriterion("PARENT_ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orParentIdLessThan(String value) {
        return addOrCriterion("PARENT_ID", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orParentIdLessThanOrEqualTo(String value) {
        return addOrCriterion("PARENT_ID", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orParentIdIsNull() {
        return addOrCriterion("PARENT_ID", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orParentIdIsNotNull() {
        return addOrCriterion("PARENT_ID", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orParentIdLikeBoth(String value) {
        return addOrCriterion("PARENT_ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orParentIdLikeLeft(String value) {
        return addOrCriterion("PARENT_ID", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orParentIdLikeRigth(String value) {
        return addOrCriterion("PARENT_ID", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orParentIdNotLikeBoth(String value) {
        return addOrCriterion("PARENT_ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orParentIdNotLikeLeft(String value) {
        return addOrCriterion("PARENT_ID", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orParentIdNotLikeRigth(String value) {
        return addOrCriterion("PARENT_ID", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByParentId(boolean isDesc) {
        return addOrderBy("PARENT_ID", isDesc);
    }

    public IamGroupSqlBuilder andLftEqualTo(Integer value) {
        return addAndCriterion("lft", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andLftNotEqualTo(Integer value) {
        return addAndCriterion("lft", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andLftGreaterThan(Integer value) {
        return addAndCriterion("lft", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andLftGreaterThanOrEqualTo(Integer value) {
        return addAndCriterion("lft", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andLftLessThan(Integer value) {
        return addAndCriterion("lft", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andLftLessThanOrEqualTo(Integer value) {
        return addAndCriterion("lft", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andLftIsNull() {
        return addAndCriterion("lft", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andLftIsNotNull() {
        return addAndCriterion("lft", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andLftLikeBoth(Integer value) {
        return addAndCriterion("lft", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andLftLikeLeft(Integer value) {
        return addAndCriterion("lft", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andLftLikeRigth(Integer value) {
        return addAndCriterion("lft", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andLftNotLikeBoth(Integer value) {
        return addAndCriterion("lft", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andLftNotLikeLeft(Integer value) {
        return addAndCriterion("lft", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andLftNotLikeRigth(Integer value) {
        return addAndCriterion("lft", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orLftEqualTo(Integer value) {
        return addOrCriterion("lft", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orLftNotEqualTo(Integer value) {
        return addOrCriterion("lft", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orLftGreaterThan(Integer value) {
        return addOrCriterion("lft", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orLftGreaterThanOrEqualTo(Integer value) {
        return addOrCriterion("lft", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orLftLessThan(Integer value) {
        return addOrCriterion("lft", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orLftLessThanOrEqualTo(Integer value) {
        return addOrCriterion("lft", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orLftIsNull() {
        return addOrCriterion("lft", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orLftIsNotNull() {
        return addOrCriterion("lft", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orLftLikeBoth(Integer value) {
        return addOrCriterion("lft", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orLftLikeLeft(Integer value) {
        return addOrCriterion("lft", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orLftLikeRigth(Integer value) {
        return addOrCriterion("lft", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orLftNotLikeBoth(Integer value) {
        return addOrCriterion("lft", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orLftNotLikeLeft(Integer value) {
        return addOrCriterion("lft", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orLftNotLikeRigth(Integer value) {
        return addOrCriterion("lft", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByLft(boolean isDesc) {
        return addOrderBy("lft", isDesc);
    }

    public IamGroupSqlBuilder andRgtEqualTo(Integer value) {
        return addAndCriterion("rgt", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andRgtNotEqualTo(Integer value) {
        return addAndCriterion("rgt", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andRgtGreaterThan(Integer value) {
        return addAndCriterion("rgt", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andRgtGreaterThanOrEqualTo(Integer value) {
        return addAndCriterion("rgt", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andRgtLessThan(Integer value) {
        return addAndCriterion("rgt", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andRgtLessThanOrEqualTo(Integer value) {
        return addAndCriterion("rgt", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andRgtIsNull() {
        return addAndCriterion("rgt", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andRgtIsNotNull() {
        return addAndCriterion("rgt", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andRgtLikeBoth(Integer value) {
        return addAndCriterion("rgt", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andRgtLikeLeft(Integer value) {
        return addAndCriterion("rgt", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andRgtLikeRigth(Integer value) {
        return addAndCriterion("rgt", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andRgtNotLikeBoth(Integer value) {
        return addAndCriterion("rgt", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andRgtNotLikeLeft(Integer value) {
        return addAndCriterion("rgt", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andRgtNotLikeRigth(Integer value) {
        return addAndCriterion("rgt", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orRgtEqualTo(Integer value) {
        return addOrCriterion("rgt", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orRgtNotEqualTo(Integer value) {
        return addOrCriterion("rgt", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orRgtGreaterThan(Integer value) {
        return addOrCriterion("rgt", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orRgtGreaterThanOrEqualTo(Integer value) {
        return addOrCriterion("rgt", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orRgtLessThan(Integer value) {
        return addOrCriterion("rgt", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orRgtLessThanOrEqualTo(Integer value) {
        return addOrCriterion("rgt", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orRgtIsNull() {
        return addOrCriterion("rgt", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orRgtIsNotNull() {
        return addOrCriterion("rgt", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orRgtLikeBoth(Integer value) {
        return addOrCriterion("rgt", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orRgtLikeLeft(Integer value) {
        return addOrCriterion("rgt", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orRgtLikeRigth(Integer value) {
        return addOrCriterion("rgt", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orRgtNotLikeBoth(Integer value) {
        return addOrCriterion("rgt", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orRgtNotLikeLeft(Integer value) {
        return addOrCriterion("rgt", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orRgtNotLikeRigth(Integer value) {
        return addOrCriterion("rgt", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByRgt(boolean isDesc) {
        return addOrderBy("rgt", isDesc);
    }

    public IamGroupSqlBuilder andStateEqualTo(String value) {
        return addAndCriterion("STATE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andStateNotEqualTo(String value) {
        return addAndCriterion("STATE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andStateGreaterThan(String value) {
        return addAndCriterion("STATE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andStateGreaterThanOrEqualTo(String value) {
        return addAndCriterion("STATE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andStateLessThan(String value) {
        return addAndCriterion("STATE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andStateLessThanOrEqualTo(String value) {
        return addAndCriterion("STATE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andStateIsNull() {
        return addAndCriterion("STATE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andStateIsNotNull() {
        return addAndCriterion("STATE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andStateLikeBoth(String value) {
        return addAndCriterion("STATE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andStateLikeLeft(String value) {
        return addAndCriterion("STATE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andStateLikeRigth(String value) {
        return addAndCriterion("STATE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andStateNotLikeBoth(String value) {
        return addAndCriterion("STATE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andStateNotLikeLeft(String value) {
        return addAndCriterion("STATE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andStateNotLikeRigth(String value) {
        return addAndCriterion("STATE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orStateEqualTo(String value) {
        return addOrCriterion("STATE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orStateNotEqualTo(String value) {
        return addOrCriterion("STATE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orStateGreaterThan(String value) {
        return addOrCriterion("STATE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orStateGreaterThanOrEqualTo(String value) {
        return addOrCriterion("STATE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orStateLessThan(String value) {
        return addOrCriterion("STATE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orStateLessThanOrEqualTo(String value) {
        return addOrCriterion("STATE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orStateIsNull() {
        return addOrCriterion("STATE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orStateIsNotNull() {
        return addOrCriterion("STATE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orStateLikeBoth(String value) {
        return addOrCriterion("STATE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orStateLikeLeft(String value) {
        return addOrCriterion("STATE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orStateLikeRigth(String value) {
        return addOrCriterion("STATE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orStateNotLikeBoth(String value) {
        return addOrCriterion("STATE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orStateNotLikeLeft(String value) {
        return addOrCriterion("STATE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orStateNotLikeRigth(String value) {
        return addOrCriterion("STATE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByState(boolean isDesc) {
        return addOrderBy("STATE", isDesc);
    }

    public IamGroupSqlBuilder andTenantCodeEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andTenantCodeNotEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andTenantCodeGreaterThan(String value) {
        return addAndCriterion("TENANT_CODE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andTenantCodeGreaterThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andTenantCodeLessThan(String value) {
        return addAndCriterion("TENANT_CODE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andTenantCodeLessThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andTenantCodeIsNull() {
        return addAndCriterion("TENANT_CODE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andTenantCodeIsNotNull() {
        return addAndCriterion("TENANT_CODE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andTenantCodeLikeBoth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andTenantCodeLikeLeft(String value) {
        return addAndCriterion("TENANT_CODE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andTenantCodeLikeRigth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andTenantCodeNotLikeBoth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andTenantCodeNotLikeLeft(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andTenantCodeNotLikeRigth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orTenantCodeEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orTenantCodeNotEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orTenantCodeGreaterThan(String value) {
        return addOrCriterion("TENANT_CODE", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orTenantCodeGreaterThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orTenantCodeLessThan(String value) {
        return addOrCriterion("TENANT_CODE", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orTenantCodeLessThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orTenantCodeIsNull() {
        return addOrCriterion("TENANT_CODE", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orTenantCodeIsNotNull() {
        return addOrCriterion("TENANT_CODE", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orTenantCodeLikeBoth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orTenantCodeLikeLeft(String value) {
        return addOrCriterion("TENANT_CODE", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orTenantCodeLikeRigth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orTenantCodeNotLikeBoth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orTenantCodeNotLikeLeft(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orTenantCodeNotLikeRigth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByTenantCode(boolean isDesc) {
        return addOrderBy("TENANT_CODE", isDesc);
    }

    public IamGroupSqlBuilder andTenantNameEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andTenantNameNotEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andTenantNameGreaterThan(String value) {
        return addAndCriterion("TENANT_NAME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andTenantNameGreaterThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andTenantNameLessThan(String value) {
        return addAndCriterion("TENANT_NAME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andTenantNameLessThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andTenantNameIsNull() {
        return addAndCriterion("TENANT_NAME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andTenantNameIsNotNull() {
        return addAndCriterion("TENANT_NAME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andTenantNameLikeBoth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andTenantNameLikeLeft(String value) {
        return addAndCriterion("TENANT_NAME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andTenantNameLikeRigth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andTenantNameNotLikeBoth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andTenantNameNotLikeLeft(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andTenantNameNotLikeRigth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orTenantNameEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orTenantNameNotEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orTenantNameGreaterThan(String value) {
        return addOrCriterion("TENANT_NAME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orTenantNameGreaterThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orTenantNameLessThan(String value) {
        return addOrCriterion("TENANT_NAME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orTenantNameLessThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orTenantNameIsNull() {
        return addOrCriterion("TENANT_NAME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orTenantNameIsNotNull() {
        return addOrCriterion("TENANT_NAME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orTenantNameLikeBoth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orTenantNameLikeLeft(String value) {
        return addOrCriterion("TENANT_NAME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orTenantNameLikeRigth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orTenantNameNotLikeBoth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orTenantNameNotLikeLeft(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orTenantNameNotLikeRigth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByTenantName(boolean isDesc) {
        return addOrderBy("TENANT_NAME", isDesc);
    }

    public IamGroupSqlBuilder andCreateUserEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andCreateUserNotEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andCreateUserGreaterThan(String value) {
        return addAndCriterion("CREATE_USER", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andCreateUserGreaterThanOrEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andCreateUserLessThan(String value) {
        return addAndCriterion("CREATE_USER", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andCreateUserLessThanOrEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andCreateUserIsNull() {
        return addAndCriterion("CREATE_USER", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andCreateUserIsNotNull() {
        return addAndCriterion("CREATE_USER", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andCreateUserLikeBoth(String value) {
        return addAndCriterion("CREATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andCreateUserLikeLeft(String value) {
        return addAndCriterion("CREATE_USER", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andCreateUserLikeRigth(String value) {
        return addAndCriterion("CREATE_USER", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andCreateUserNotLikeBoth(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andCreateUserNotLikeLeft(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andCreateUserNotLikeRigth(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orCreateUserEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orCreateUserNotEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orCreateUserGreaterThan(String value) {
        return addOrCriterion("CREATE_USER", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orCreateUserGreaterThanOrEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orCreateUserLessThan(String value) {
        return addOrCriterion("CREATE_USER", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orCreateUserLessThanOrEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orCreateUserIsNull() {
        return addOrCriterion("CREATE_USER", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orCreateUserIsNotNull() {
        return addOrCriterion("CREATE_USER", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orCreateUserLikeBoth(String value) {
        return addOrCriterion("CREATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orCreateUserLikeLeft(String value) {
        return addOrCriterion("CREATE_USER", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orCreateUserLikeRigth(String value) {
        return addOrCriterion("CREATE_USER", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orCreateUserNotLikeBoth(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orCreateUserNotLikeLeft(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orCreateUserNotLikeRigth(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByCreateUser(boolean isDesc) {
        return addOrderBy("CREATE_USER", isDesc);
    }

    public IamGroupSqlBuilder andUpdateUserEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateUserNotEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateUserGreaterThan(String value) {
        return addAndCriterion("UPDATE_USER", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andUpdateUserGreaterThanOrEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateUserLessThan(String value) {
        return addAndCriterion("UPDATE_USER", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andUpdateUserLessThanOrEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateUserIsNull() {
        return addAndCriterion("UPDATE_USER", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andUpdateUserIsNotNull() {
        return addAndCriterion("UPDATE_USER", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andUpdateUserLikeBoth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andUpdateUserLikeLeft(String value) {
        return addAndCriterion("UPDATE_USER", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andUpdateUserLikeRigth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andUpdateUserNotLikeBoth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andUpdateUserNotLikeLeft(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andUpdateUserNotLikeRigth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateUserEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateUserNotEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateUserGreaterThan(String value) {
        return addOrCriterion("UPDATE_USER", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orUpdateUserGreaterThanOrEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateUserLessThan(String value) {
        return addOrCriterion("UPDATE_USER", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orUpdateUserLessThanOrEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateUserIsNull() {
        return addOrCriterion("UPDATE_USER", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orUpdateUserIsNotNull() {
        return addOrCriterion("UPDATE_USER", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orUpdateUserLikeBoth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateUserLikeLeft(String value) {
        return addOrCriterion("UPDATE_USER", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orUpdateUserLikeRigth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateUserNotLikeBoth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateUserNotLikeLeft(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orUpdateUserNotLikeRigth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByUpdateUser(boolean isDesc) {
        return addOrderBy("UPDATE_USER", isDesc);
    }

    public IamGroupSqlBuilder andCreateTimeEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andCreateTimeNotEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andCreateTimeGreaterThan(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andCreateTimeGreaterThanOrEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andCreateTimeLessThan(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andCreateTimeLessThanOrEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andCreateTimeIsNull() {
        return addAndCriterion("CREATE_TIME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andCreateTimeIsNotNull() {
        return addAndCriterion("CREATE_TIME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andCreateTimeLikeBoth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andCreateTimeLikeLeft(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andCreateTimeLikeRigth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andCreateTimeNotLikeBoth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andCreateTimeNotLikeLeft(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andCreateTimeNotLikeRigth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orCreateTimeEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orCreateTimeNotEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orCreateTimeGreaterThan(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orCreateTimeGreaterThanOrEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orCreateTimeLessThan(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orCreateTimeLessThanOrEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orCreateTimeIsNull() {
        return addOrCriterion("CREATE_TIME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orCreateTimeIsNotNull() {
        return addOrCriterion("CREATE_TIME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orCreateTimeLikeBoth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orCreateTimeLikeLeft(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orCreateTimeLikeRigth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orCreateTimeNotLikeBoth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orCreateTimeNotLikeLeft(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orCreateTimeNotLikeRigth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByCreateTime(boolean isDesc) {
        return addOrderBy("CREATE_TIME", isDesc);
    }

    public IamGroupSqlBuilder andUpdateTimeEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateTimeNotEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateTimeGreaterThan(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andUpdateTimeGreaterThanOrEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateTimeLessThan(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andUpdateTimeLessThanOrEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andUpdateTimeIsNull() {
        return addAndCriterion("UPDATE_TIME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andUpdateTimeIsNotNull() {
        return addAndCriterion("UPDATE_TIME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andUpdateTimeLikeBoth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andUpdateTimeLikeLeft(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andUpdateTimeLikeRigth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andUpdateTimeNotLikeBoth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andUpdateTimeNotLikeLeft(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andUpdateTimeNotLikeRigth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateTimeEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateTimeNotEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateTimeGreaterThan(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orUpdateTimeGreaterThanOrEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateTimeLessThan(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orUpdateTimeLessThanOrEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orUpdateTimeIsNull() {
        return addOrCriterion("UPDATE_TIME", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orUpdateTimeIsNotNull() {
        return addOrCriterion("UPDATE_TIME", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orUpdateTimeLikeBoth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateTimeLikeLeft(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orUpdateTimeLikeRigth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateTimeNotLikeBoth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orUpdateTimeNotLikeLeft(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orUpdateTimeNotLikeRigth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByUpdateTime(boolean isDesc) {
        return addOrderBy("UPDATE_TIME", isDesc);
    }

    public IamGroupSqlBuilder andIsDeletedEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder andIsDeletedNotEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder andIsDeletedGreaterThan(String value) {
        return addAndCriterion("IS_DELETED", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder andIsDeletedGreaterThanOrEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andIsDeletedLessThan(String value) {
        return addAndCriterion("IS_DELETED", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder andIsDeletedLessThanOrEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder andIsDeletedIsNull() {
        return addAndCriterion("IS_DELETED", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder andIsDeletedIsNotNull() {
        return addAndCriterion("IS_DELETED", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder andIsDeletedLikeBoth(String value) {
        return addAndCriterion("IS_DELETED", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andIsDeletedLikeLeft(String value) {
        return addAndCriterion("IS_DELETED", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder andIsDeletedLikeRigth(String value) {
        return addAndCriterion("IS_DELETED", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder andIsDeletedNotLikeBoth(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder andIsDeletedNotLikeLeft(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder andIsDeletedNotLikeRigth(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orIsDeletedEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.EqualTo, value);
    }

    public IamGroupSqlBuilder orIsDeletedNotEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotEqualTo, value);
    }

    public IamGroupSqlBuilder orIsDeletedGreaterThan(String value) {
        return addOrCriterion("IS_DELETED", Operator.GreaterThan, value);
    }

    public IamGroupSqlBuilder orIsDeletedGreaterThanOrEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.GreaterThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orIsDeletedLessThan(String value) {
        return addOrCriterion("IS_DELETED", Operator.LessThan, value);
    }

    public IamGroupSqlBuilder orIsDeletedLessThanOrEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.LessThanOrEqualTo, value);
    }

    public IamGroupSqlBuilder orIsDeletedIsNull() {
        return addOrCriterion("IS_DELETED", Operator.IsNull, null);
    }

    public IamGroupSqlBuilder orIsDeletedIsNotNull() {
        return addOrCriterion("IS_DELETED", Operator.IsNotNull, null);
    }

    public IamGroupSqlBuilder orIsDeletedLikeBoth(String value) {
        return addOrCriterion("IS_DELETED", Operator.Like, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orIsDeletedLikeLeft(String value) {
        return addOrCriterion("IS_DELETED", Operator.Like, likeMark + value);
    }

    public IamGroupSqlBuilder orIsDeletedLikeRigth(String value) {
        return addOrCriterion("IS_DELETED", Operator.Like, value + likeMark);
    }

    public IamGroupSqlBuilder orIsDeletedNotLikeBoth(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamGroupSqlBuilder orIsDeletedNotLikeLeft(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotLike, likeMark + value);
    }

    public IamGroupSqlBuilder orIsDeletedNotLikeRigth(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotLike, value + likeMark);
    }

    public IamGroupSqlBuilder orderByIsDeleted(boolean isDesc) {
        return addOrderBy("IS_DELETED", isDesc);
    }
}